/**
 * 用户相关 API 接口
 * 对接后端 http://124.71.77.44:2233
 */

const request = require('./request.js');
const aes = require('./aes.js');

/**
 * 发送短信验证码
 * @param {string} userPhone - 手机号
 * @param {string} verificationCode - 验证码
 * @returns {Promise}
 */
function sendSmsCode(userPhone, verificationCode) {
  console.log('📤 =============== 发送短信验证码 ===============');
  console.log('📱 手机号:', userPhone);
  console.log('🔢 验证码:', verificationCode);

  // 构建请求数据（严格按照接口文档）
  const requestData = {
    userPhone: userPhone,
    userCode: verificationCode, // 注意：字段名是 userCode，不是 code
    timestamp: Math.floor(Date.now() / 1000)  // ⚠️ 必须是数字类型
  };

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷:', encryptedPayload);

  // 发送请求
  return request.post('/users/send_sms_code/', encryptedPayload, {
    showLoading: true,
    loadingText: '发送中...'
  }).then(response => {
    console.log('✅ 短信验证码发送成功');
    return response;
  }).catch(error => {
    console.error('❌ 短信验证码发送失败:', error);
    throw error;
  });
}

/**
 * 🔥 微信授权获取手机号
 * @param {string} code - 微信返回的动态令牌
 * @returns {Promise}
 */
function getPhoneNumber(code) {
  console.log('📱 =============== 微信授权获取手机号 ===============');
  console.log('🔑 Code:', code);

  // 构建请求数据（严格按照接口文档）
  const requestData = {
    code: code,
    timestamp: Math.floor(Date.now() / 1000)  // ⚠️ 必须是数字类型
  };

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷:', encryptedPayload);

  // 发送请求
  return request.post('/users/get_phone_number/', encryptedPayload, {
    showLoading: true,
    loadingText: '获取中...'
  }).then(response => {
    console.log('✅ 手机号获取成功');
    console.log('📱 手机号:', response.data?.phone);
    return response;
  }).catch(error => {
    console.error('❌ 手机号获取失败:', error);
    throw error;
  });
}

/**
 * 检查手机号是否注册并获取用户信息
 * @param {string} userPhone - 手机号
 * @returns {Promise}
 */
function checkPhone(userPhone) {
  console.log('🔍 =============== 检查用户信息 ===============');
  console.log('📱 手机号:', userPhone);

  // 构建请求数据（严格按照接口文档）
  const requestData = {
    userPhone: userPhone,
    timestamp: Math.floor(Date.now() / 1000)  // ⚠️ 必须是数字类型
  };

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷:', encryptedPayload);

  // 发送请求
  return request.post('/users/check_phone/', encryptedPayload, {
    showLoading: true,
    loadingText: '登录中...'
  }).then(response => {
    console.log('✅ 用户信息查询成功');
    console.log('📊 响应数据:', response);

    // 检查用户是否存在
    if (response.exists && response.data) {
      console.log('👤 用户信息:');
      console.log('  🆔 用户ID:', response.data.userid);
      console.log('  📛 用户名:', response.data.username);
      console.log('  📱 手机号:', response.data.userPhone);
      console.log('  💰 积分:', response.data.userPoints);
      console.log('  ⭐ 等级:', response.data.userLevel);
      console.log('  🔐 融云Token:', response.data.extraData?.token);
    } else {
      console.log('⚠️ 用户不存在，需要注册');
    }

    return response;
  }).catch(error => {
    console.error('❌ 用户信息查询失败:', error);
    throw error;
  });
}

/**
 * 用户注册
 * @param {string} userPhone - 手机号
 * @param {string} userType - 用户类型："0"=个人, "1"=商家
 * @returns {Promise}
 */
function registerWithPhone(userPhone, userType = '0') {
  console.log('📝 =============== 用户注册 ===============');
  console.log('📱 手机号:', userPhone);
  console.log('👤 用户类型:', userType);

  // 构建请求数据（严格按照接口文档）
  const requestData = {
    userPhone: userPhone,
    userCode: userType, // "0"=个人用户, "1"=商家用户
    GenToken: '1', // 生成融云token
    timestamp: Math.floor(Date.now() / 1000)  // ⚠️ 必须是数字类型
  };

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷:', encryptedPayload);

  // 发送请求
  return request.post('/users/create_with_phone/', encryptedPayload, {
    showLoading: true,
    loadingText: '注册中...'
  }).then(response => {
    console.log('✅ 用户注册成功');
    return response;
  }).catch(error => {
    console.error('❌ 用户注册失败:', error);
    throw error;
  });
}

/**
 * 上传用户图片
 * @param {number} userId - 用户ID
 * @param {string} filePath - 图片临时路径
 * @returns {Promise}
 */
function uploadUserImage(userId, filePath) {
  console.log('📤 =============== 上传用户图片 ===============');
  console.log('👤 用户ID:', userId);
  console.log('🖼️ 图片路径:', filePath);

  return new Promise((resolve, reject) => {
    wx.uploadFile({
      url: request.BASE_URL + '/users/upload_image/',
      filePath: filePath,
      name: 'file',
      formData: {
        'user_id': userId
      },
      success: (res) => {
        console.log('✅ 图片上传成功');
        console.log('📊 响应数据:', res.data);
        
        try {
          const data = JSON.parse(res.data);
          console.log('🔗 图片URL:', data.image_url);
          resolve(data);
        } catch (e) {
          console.error('❌ 解析响应失败:', e);
          reject(e);
        }
      },
      fail: (error) => {
        console.error('❌ 图片上传失败:', error);
        reject(error);
      }
    });
  });
}

/**
 * 上传活动图片（与playtrue3保持一致，使用用户图片上传接口）
 * @param {number} userId - 用户ID
 * @param {string} filePath - 图片文件路径
 * @returns {Promise}
 */
function uploadActivityImage(userId, filePath) {
  console.log('📤 =============== 上传活动图片 ===============');
  console.log('👤 用户ID:', userId);
  console.log('🖼️ 图片路径:', filePath);
  console.log('🎯 使用接口: /users/upload_image/ (与playtrue3保持一致)');

  return new Promise((resolve, reject) => {
    wx.uploadFile({
      url: request.BASE_URL + '/users/upload_image/',  // ✅ 使用用户图片上传接口，与playtrue3一致
      filePath: filePath,
      name: 'file',
      formData: {
        'user_id': userId
      },
      success: (res) => {
        console.log('✅ 活动图片上传成功');
        console.log('📊 响应数据:', res.data);
        
        try {
          const data = JSON.parse(res.data);
          console.log('🔗 图片URL:', data.image_url);
          resolve(data);
        } catch (e) {
          console.error('❌ 解析响应失败:', e);
          reject(e);
        }
      },
      fail: (error) => {
        console.error('❌ 活动图片上传失败:', error);
        reject(error);
      }
    });
  });
}

/**
 * 更新用户信息
 * @param {Object} userInfo - 用户信息对象
 * @returns {Promise}
 */
function updateUserInfo(userInfo) {
  console.log('📝 =============== 更新用户信息 ===============');
  console.log('📊 更新数据:', userInfo);

  // 构建请求数据（必须包含 userPhone）
  const requestData = {
    userPhone: userInfo.userPhone,
    timestamp: Math.floor(Date.now() / 1000)
  };

  // 添加可选参数
  if (userInfo.username) requestData.username = userInfo.username;
  if (userInfo.userAvatarUrl) requestData.userAvatarUrl = userInfo.userAvatarUrl;
  if (userInfo.userGender) requestData.userGender = userInfo.userGender;
  if (userInfo.userAge !== undefined) requestData.userAge = userInfo.userAge;
  if (userInfo.userBirthday) requestData.userBirthday = userInfo.userBirthday;
  if (userInfo.userSignature) requestData.userSignature = userInfo.userSignature;
  if (userInfo.userFrequentPlaces) requestData.userFrequentPlaces = userInfo.userFrequentPlaces;
  if (userInfo.userHobbies) requestData.userHobbies = userInfo.userHobbies;
  if (userInfo.userImgUrls) requestData.userImgUrls = userInfo.userImgUrls;

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷:', encryptedPayload);

  // 发送请求
  return request.post('/users/update/', encryptedPayload, {
    showLoading: true,
    loadingText: '保存中...'
  }).then(response => {
    console.log('✅ 用户信息更新成功');
    return response;
  }).catch(error => {
    console.error('❌ 用户信息更新失败:', error);
    throw error;
  });
}

/**
 * 获取附近的活动列表
 * @param {number} latitude - 纬度
 * @param {number} longitude - 经度
 * @param {number} radius - 搜索半径（公里），默认50
 * @param {number} limit - 返回数量限制，默认50
 * @param {string} sortBy - 排序方式：'distance'(距离), 'time'(时间), 'distance_time'(距离+时间)
 * @param {string} order - 排序顺序：'asc'(升序), 'desc'(降序)
 * @returns {Promise}
 */
function getNearbyActivities(latitude = 39.915, longitude = 116.404, radius = 50.0, limit = 50, sortBy = 'distance_time', order = 'asc') {
  console.log('🎯 =============== 获取附近活动 ===============');
  console.log('📍 纬度:', latitude);
  console.log('📍 经度:', longitude);
  console.log('📏 搜索半径:', radius, 'km');
  console.log('🔢 数量限制:', limit);
  console.log('🔄 排序方式:', sortBy);
  console.log('📊 排序顺序:', order);

  // 构建请求数据（严格按照接口文档）
  const requestData = {
    latitude: latitude,
    longitude: longitude,
    radius: radius,
    limit: limit,
    sort_by: sortBy,     // 🔥 排序字段：distance(距离), time(时间), distance_time(综合)
    order: order,        // 🔥 排序顺序：asc(升序), desc(降序)
    timestamp: Math.floor(Date.now() / 1000)  // ⚠️ 必须是数字类型
  };

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷:', encryptedPayload);

  // 发送请求
  return request.post('/activities/nearby/', encryptedPayload, {
    showLoading: true,
    loadingText: '加载活动中...'
  }).then(response => {
    console.log('✅ 活动列表获取成功');
    console.log('📊 总数:', response.data?.length || 0);
    console.log('📄 分页信息:', response.pagination);
    console.log('🔄 排序方式:', sortBy, '(', order, ')');
    return response;
  }).catch(error => {
    console.error('❌ 活动列表获取失败:', error);
    throw error;
  });
}

/**
 * 获取活动详情
 * @param {number} activityId - 活动ID
 * @returns {Promise}
 */
function getActivityDetail(activityId) {
  console.log('🔍 =============== 获取活动详情 ===============');
  console.log('🆔 活动ID:', activityId);

  // 构建请求数据
  const requestData = {
    activityId: activityId,
    timestamp: Math.floor(Date.now() / 1000)
  };

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);

  // 发送请求
  return request.post('/query/activity_user/', encryptedPayload, {
    showLoading: true,
    loadingText: '加载详情中...'
  }).then(response => {
    console.log('✅ 活动详情获取成功');
    console.log('📊 活动信息:', response.activity);
    console.log('👤 发布者信息:', response.user);
    return response;
  }).catch(error => {
    console.error('❌ 活动详情获取失败:', error);
    throw error;
  });
}

/**
 * 获取用户发布的内容（我的发布）
 * @param {number} userId - 用户ID
 * @param {number} days - 查询天数，默认30天
 * @returns {Promise}
 */
function getUserContent(userId, days = 30) {
  console.log('📚 =============== 获取用户内容 ===============');
  console.log('👤 用户ID:', userId);
  console.log('📅 查询天数:', days);

  // 构建请求数据
  const requestData = {
    userId: userId,
    days: days,
    timestamp: Math.floor(Date.now() / 1000)
  };

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);

  // 发送请求
  return request.post('/users/content/', encryptedPayload, {
    showLoading: true,
    loadingText: '加载中...'
  }).then(response => {
    console.log('✅ 用户内容获取成功');
    console.log('📊 活动数量:', response.activities?.length || 0);
    console.log('📊 已结束活动数量:', response.endedActivities?.length || 0);
    console.log('📊 评论数量:', response.comments?.length || 0);
    console.log('📊 参与活动数量:', response.participatedActivities?.length || 0);
    return response;
  }).catch(error => {
    console.error('❌ 用户内容获取失败:', error);
    throw error;
  });
}

/**
 * 🔥 获取用户过滤内容（查看他人主页）
 * @param {number} userId - 目标用户ID
 * @param {string} contentType - 内容类型（'activities' 或 'comments'），默认'activities'
 * @returns {Promise}
 */
function getUserFilteredContent(userId, contentType = 'activities') {
  console.log('👤 =============== 获取用户过滤内容 ===============');
  console.log('🎯 目标用户ID:', userId);
  console.log('📝 内容类型:', contentType);

  // 构建请求数据（与 Flutter 保持一致）
  const requestData = {
    userId: userId,
    content_type: contentType,  // 使用下划线格式
    timestamp: Math.floor(Date.now() / 1000)
  };

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷已生成');

  // 发送请求
  return request.post('/users/filtered_content/', encryptedPayload, {
    showLoading: true,
    loadingText: '加载中...'
  }).then(response => {
    console.log('✅ 用户过滤内容获取成功');
    console.log('📊 用户信息:', response.user);
    console.log('👥 好友数量:', response.friend_count);
    if (contentType === 'activities' && response.activities) {
      console.log('📊 活动数量:', response.activities.length);
    }
    if (contentType === 'comments' && response.comments) {
      console.log('📊 评论数量:', response.comments.length);
    }
    return response;
  }).catch(error => {
    console.error('❌ 用户过滤内容获取失败:', error);
    throw error;
  });
}

/**
 * 🔥 加入活动（集成融云IM通知）
 * @param {number} activityId - 活动ID
 * @param {number} userId - 用户ID
 * @param {string} participantStatus - 参与者状态，默认'待审核'
 * @param {Object} options - 可选参数 { activityTitle, publisherId, userName }
 * @returns {Promise}
 */
function joinActivity(activityId, userId, participantStatus = '待审核', options = {}) {
  console.log('🎯 =============== 加入活动 ===============');
  console.log('📝 活动ID:', activityId);
  console.log('👤 用户ID:', userId);
  console.log('📋 参与状态:', participantStatus);

  // 构建请求数据（与 Flutter 保持一致）
  const requestData = {
    activityId: activityId,
    userId: userId,
    participantStatus: participantStatus,
    timestamp: Math.floor(Date.now() / 1000) // 时间戳（秒级）
  };

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷已生成');

  // 发送请求到 /activities/participants/
  return request.post('/activities/participants/', encryptedPayload, {
    showLoading: true,
    loadingText: '正在加入...'
  }).then(response => {
    console.log('✅ 加入活动成功:', response);
    
    // 🔥 统一处理：发送融云活动申请推送消息（参考Flutter项目实现）
    _sendRongCloudActivityRequestPush(activityId, options).catch(error => {
      console.warn('⚠️ 融云活动申请推送发送失败（不影响主流程）:', error);
    });
    
    return response;
  }).catch(error => {
    console.error('❌ 加入活动失败:', error);
    throw error;
  });
}

/**
 * 检查好友关系
 * @param {number} userId - 当前用户ID
 * @param {number} targetUserId - 目标用户ID
 * @returns {Promise}
 */
function checkFriendRelationship(userId, targetUserId) {
  console.log('🔍 =============== 检查好友关系 ===============');
  console.log('👤 当前用户ID:', userId);
  console.log('👤 目标用户ID:', targetUserId);

  // 🔥 构建请求数据（使用与Flutter/Android一致的字段名：user1_id, user2_id）
  const requestData = {
    user1_id: userId.toString(),      // ✅ 修改为 user1_id（字符串格式，与Flutter一致）
    user2_id: targetUserId.toString(), // ✅ 修改为 user2_id（字符串格式，与Flutter一致）
    timestamp: Math.floor(Date.now() / 1000)
  };

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷已生成');

  // 发送请求
  return request.post('/friends/check_relationship/', encryptedPayload, {
    showLoading: false  // 不显示加载提示，静默检查
  }).then(response => {
    console.log('✅ 好友关系检查成功');
    console.log('📊 关系状态:', response);
    return response;
  }).catch(error => {
    console.error('❌ 好友关系检查失败:', error);
    throw error;
  });
}

/**
 * 🔥 发送好友申请（集成积分权限检查 + 融云IM通知）
 * @param {number} senderId - 发送者ID
 * @param {number} receiverId - 接收者ID
 * @param {string} message - 申请消息
 * @param {number} free - 是否免费（可选，不传则自动计算）
 * @returns {Promise}
 */
function sendFriendRequest(senderId, receiverId, message = '我想加你为好友', free = null) {
  console.log('🤝 =============== 发送好友申请（集成权限检查） ===============');
  console.log('👤 发送者ID:', senderId);
  console.log('👤 接收者ID:', receiverId);
  console.log('💬 申请消息:', message);

  // 🔥 如果没有传入free参数，自动计算权限
  let calculatedFree = free;
  if (free === null || free === undefined) {
    console.log('💰 开始自动计算加好友权限...');
    
    // 引入permission模块
    const permission = require('./permission.js');
    const storage = require('./storage.js');
    
    try {
      // 🔥 先初始化权限系统（确保权限变量正确设置）
      const userInfo = storage.getUserInfo();
      if (userInfo && userInfo.userPoints !== undefined) {
        console.log('🔧 初始化权限系统，用户积分:', userInfo.userPoints);
        permission.accordingToUserPointsForPermission(userInfo.userPoints);
      } else {
        console.warn('⚠️ 无法获取用户积分，使用默认权限配置');
      }
      
      // 然后计算free参数
      calculatedFree = permission.calculateAddFriendFree();
      console.log('✅ 权限计算完成:', calculatedFree === 1 ? '免费' : `付费(${permission.getAddFriendCost()}积分)`);
    } catch (error) {
      // 🔥 微信免费开放：此段积分不足逻辑已禁用（permission.calculateAddFriendFree()直接返回免费，不会抛异常）
      console.error('❌ 积分不足，无法加好友:', error.message);
      
      // 🔥 积分不足时，弹窗提示并引导充值（已禁用）
      return new Promise((resolve, reject) => {
        wx.showModal({
          title: '积分不足',
          content: error.message,
          showCancel: true,
          confirmText: '去充值',
          cancelText: '取消',
          success: (res) => {
            if (res.confirm) {
              wx.navigateTo({ url: '/pages/funds/index' });
            }
            reject(error);  // 拒绝Promise，不继续执行
          },
          fail: () => {
            reject(error);
          }
        });
      });
    }
  } else {
    console.log('💰 使用外部传入的free参数:', free);
    calculatedFree = free;
  }

  // 构建请求数据（与项目其他接口保持一致 - timestamp使用数字类型）
  const requestData = {
    sender_id: senderId,
    receiver_id: receiverId,
    message: message,
    free: calculatedFree,  // 🔥 使用计算后的free值
    timestamp: Math.floor(Date.now() / 1000)  // 🔥 数字类型（与main/index.js一致）
  };

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷已生成');

  // 发送请求
  return request.post('/friends/send_request/', encryptedPayload, {
    showLoading: true,
    loadingText: '发送中...'
  }).then(response => {
    console.log('✅ 好友申请发送成功');
    console.log('📊 响应数据:', response);
    
    // 🔥 发送成功后自动增加加好友计数（集中处理）
    if (free === null || free === undefined) {
      const permission = require('./permission.js');
      permission.incrementAddFriendCount();
      console.log('✅ 已自动增加加好友计数');
    }
    
    // 🔥 统一处理：发送融云好友申请推送消息（参考Flutter项目实现）
    _sendRongCloudFriendRequestPush(receiverId).catch(error => {
      console.warn('⚠️ 融云好友申请推送发送失败（不影响主流程）:', error);
    });
    
    return response;
  }).catch(error => {
    console.error('❌ 好友申请发送失败:', error);
    throw error;
  });
}

/**
 * 🔥 获取好友列表（参考Flutter项目实现）
 * @param {number} userId - 用户ID
 * @param {number} groupId - 分组ID（可选）
 * @param {string} status - 好友状态筛选（可选）
 * @returns {Promise}
 */
function getFriendList(userId, groupId = null, status = null) {
  console.log('👥 =============== 获取好友列表（AES加密） ===============');
  console.log('👤 用户ID:', userId);
  console.log('📁 分组ID:', groupId || '全部');
  console.log('📊 状态筛选:', status || '全部');

  // 构建请求数据（与Flutter项目保持一致）
  const requestData = {
    user_id: userId,  // ✅ 使用下划线格式（与后端一致）
    timestamp: Math.floor(Date.now() / 1000)
  };

  // 可选参数
  if (groupId !== null) {
    requestData.group_id = groupId;
  }
  if (status !== null && status !== '') {
    requestData.status = status;
  }

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷已生成');

  // 发送请求
  return request.post('/friends/list/', encryptedPayload, {
    showLoading: false  // 静默加载，不显示loading
  }).then(response => {
    console.log('✅ 好友列表获取成功');
    console.log('👥 好友数量:', response.count || 0);
    
    if (response.data && Array.isArray(response.data)) {
      console.log('📝 好友列表详情:');
      response.data.forEach((friend, index) => {
        console.log(`  👤 ${index + 1}. ${friend.username || '未知'} (ID: ${friend.friend_id || friend.friendId})`);
      });
    }
    
    return response;
  }).catch(error => {
    console.error('❌ 好友列表获取失败:', error);
    throw error;
  });
}

/**
 * 🔥 统一处理：发送融云好友申请推送消息（参考Flutter项目）
 * @param {number} targetUserId - 目标用户ID
 * @returns {Promise}
 */
function _sendRongCloudFriendRequestPush(targetUserId) {
  return new Promise(async (resolve, reject) => {
    try {
      console.log('📤 =============== 统一融云好友申请推送开始 ===============');
      console.log('🎯 目标用户ID:', targetUserId);
      
      // 🔥 1. 获取目标用户的融云用户ID（通常是手机号）
      let targetRongCloudUserId = null;
      
      try {
        console.log('🔍 尝试通过API获取用户手机号...');
        const userInfoResponse = await getUserFilteredContent(targetUserId, 'activities');
        
        if (userInfoResponse.status === 'success' && userInfoResponse.user && userInfoResponse.user.userPhone) {
          targetRongCloudUserId = userInfoResponse.user.userPhone;
          console.log('📱 通过API获取手机号成功:', targetRongCloudUserId);
        } else {
          console.warn('⚠️ API响应中未找到用户手机号');
        }
      } catch (apiError) {
        console.error('❌ 获取用户信息异常:', apiError);
      }
      
      // 2. 验证融云用户ID（手机号）
      if (!targetRongCloudUserId) {
        console.error('❌ 无法获取目标用户的融云用户ID（手机号），跳过融云推送');
        reject(new Error('无法获取目标用户手机号'));
        return;
      }
      
      // 验证手机号格式（中国大陆手机号：11位，1开头）
      if (targetRongCloudUserId.length !== 11 || !targetRongCloudUserId.match(/^1[3-9]\d{9}$/)) {
        console.warn('⚠️ 融云用户ID格式异常:', targetRongCloudUserId, '，跳过融云推送');
        reject(new Error('手机号格式异常'));
        return;
      }
      
      console.log('✅ 目标融云用户ID验证通过:', targetRongCloudUserId);
      
      // 🔥 3. 调用融云服务发送好友申请推送（固定消息内容）
      const rongcloud = require('./rongcloud.js');
      const friendRequestMessage = '收到一条新的好友申请'; // 🔥 固定消息内容（与Flutter保持一致）
      
      console.log('📤 准备通过融云发送好友申请消息:', friendRequestMessage);
      console.log('📤 目标融云用户ID:', targetRongCloudUserId);
      
      // 发送融云消息
      rongcloud.sendTextMessage(targetRongCloudUserId, friendRequestMessage)
        .then(result => {
          console.log('✅ 统一融云好友申请推送发送成功');
          console.log('📨 消息ID:', result.messageId);
          console.log('⏰ 发送时间:', result.sentTime);
          console.log('📤 =============== 统一融云好友申请推送结束 ===============');
          resolve(result);
        })
        .catch(error => {
          console.error('❌ 统一融云好友申请推送发送失败:', error);
          console.error('📤 =============== 统一融云好友申请推送结束（失败） ===============');
          reject(error);
        });
      
    } catch (e) {
      console.error('💥 发送融云好友申请推送异常:', e);
      console.error('📤 =============== 统一融云好友申请推送异常结束 ===============');
      reject(e);
    }
  });
}

/**
 * 🔥 发送活动审核结果通知（融云IM）
 * @param {number} userId - 申请者用户ID
 * @param {string} activityTitle - 活动标题
 * @param {string} reviewResult - 审核结果（'通过' 或 '未通过'）
 * @returns {Promise}
 */
function sendActivityReviewResult(userId, activityTitle, reviewResult) {
  return new Promise(async (resolve, reject) => {
    try {
      console.log('📤 =============== 发送活动审核结果通知 ===============');
      console.log('👤 申请者ID:', userId);
      console.log('🎯 活动标题:', activityTitle);
      console.log('📝 审核结果:', reviewResult);
      
      // 🔥 1. 获取申请者的融云用户ID（手机号）
      let userRongCloudId = null;
      
      try {
        console.log('🔍 尝试通过API获取申请者手机号...');
        const userInfoResponse = await getUserFilteredContent(userId, 'activities');
        
        if (userInfoResponse.status === 'success' && userInfoResponse.user && userInfoResponse.user.userPhone) {
          userRongCloudId = userInfoResponse.user.userPhone;
          console.log('📱 通过API获取手机号成功:', userRongCloudId);
        } else {
          console.warn('⚠️ API响应中未找到用户手机号');
        }
      } catch (apiError) {
        console.error('❌ 获取用户信息异常:', apiError);
      }
      
      // 2. 验证融云用户ID（手机号）
      if (!userRongCloudId) {
        console.error('❌ 无法获取申请者的融云用户ID（手机号），跳过融云推送');
        reject(new Error('无法获取申请者手机号'));
        return;
      }
      
      // 验证手机号格式
      if (userRongCloudId.length !== 11 || !userRongCloudId.match(/^1[3-9]\d{9}$/)) {
        console.warn('⚠️ 融云用户ID格式异常:', userRongCloudId, '，跳过融云推送');
        reject(new Error('手机号格式异常'));
        return;
      }
      
      console.log('✅ 申请者融云用户ID验证通过:', userRongCloudId);
      
      // 🔥 3. 构建审核结果消息
      const resultText = reviewResult === '通过' ? '已通过' : '未通过';
      const reviewMessage = `您申请参加的活动「${activityTitle}」审核${resultText}`;
      
      console.log('📤 准备通过融云发送审核结果消息:', reviewMessage);
      console.log('📤 目标融云用户ID:', userRongCloudId);
      
      // 🔥 4. 调用融云服务发送消息
      const rongcloud = require('./rongcloud.js');
      
      rongcloud.sendTextMessage(userRongCloudId, reviewMessage)
        .then(result => {
          console.log('✅ 活动审核结果通知发送成功');
          console.log('📨 消息ID:', result.messageId);
          console.log('⏰ 发送时间:', result.sentTime);
          console.log('📤 =============== 审核结果通知结束 ===============');
          resolve(result);
        })
        .catch(error => {
          console.error('❌ 活动审核结果通知发送失败:', error);
          console.error('📤 =============== 审核结果通知结束（失败） ===============');
          reject(error);
        });
      
    } catch (e) {
      console.error('💥 发送活动审核结果通知异常:', e);
      console.error('📤 =============== 审核结果通知异常结束 ===============');
      reject(e);
    }
  });
}

/**
 * 🔥 统一处理：发送融云活动申请推送消息（参考Flutter项目）
 * @param {number} activityId - 活动ID
 * @param {Object} options - 可选参数 { activityTitle, publisherId, userName }
 * @returns {Promise}
 */
function _sendRongCloudActivityRequestPush(activityId, options = {}) {
  return new Promise(async (resolve, reject) => {
    try {
      console.log('📤 =============== 统一融云活动申请推送开始 ===============');
      console.log('🎯 活动ID:', activityId);
      console.log('📊 传入参数:', options);
      
      let activityTitle = options.activityTitle;
      let publisherId = options.publisherId;
      let userName = options.userName;
      
      // 🔥 1. 如果没有传入活动信息，通过API获取
      if (!activityTitle || !publisherId) {
        try {
          console.log('🔍 尝试通过API获取活动详情...');
          const activityResponse = await getActivityDetail(activityId);
          
          if (activityResponse.status === 'success') {
            if (activityResponse.activity) {
              activityTitle = activityResponse.activity.activityTitle;
              console.log('📝 获取活动标题成功:', activityTitle);
            }
            if (activityResponse.user) {
              publisherId = activityResponse.user.userid;
              console.log('👤 获取发布者ID成功:', publisherId);
            }
          }
        } catch (apiError) {
          console.error('❌ 获取活动详情异常:', apiError);
        }
      }
      
      // 验证必要参数
      if (!activityTitle || !publisherId) {
        console.error('❌ 缺少必要参数（活动标题或发布者ID），跳过融云推送');
        reject(new Error('缺少活动标题或发布者ID'));
        return;
      }
      
      // 🔥 2. 如果没有传入用户名，从本地存储获取
      if (!userName) {
        try {
          const storage = require('./storage.js');
          const userInfo = storage.getUserInfo();
          if (userInfo && userInfo.username) {
            userName = userInfo.username;
            console.log('👤 从本地存储获取用户名:', userName);
          }
        } catch (storageError) {
          console.error('❌ 获取用户名异常:', storageError);
        }
      }
      
      if (!userName) {
        console.warn('⚠️ 无法获取用户名，使用默认值');
        userName = '用户';
      }
      
      // 🔥 3. 获取发布者的融云用户ID（手机号）
      let publisherRongCloudUserId = null;
      
      try {
        console.log('🔍 尝试通过API获取发布者手机号...');
        const userInfoResponse = await getUserFilteredContent(publisherId, 'activities');
        
        if (userInfoResponse.status === 'success' && userInfoResponse.user && userInfoResponse.user.userPhone) {
          publisherRongCloudUserId = userInfoResponse.user.userPhone;
          console.log('📱 通过API获取发布者手机号成功:', publisherRongCloudUserId);
        } else {
          console.warn('⚠️ API响应中未找到发布者手机号');
        }
      } catch (apiError) {
        console.error('❌ 获取发布者信息异常:', apiError);
      }
      
      // 4. 验证融云用户ID（手机号）
      if (!publisherRongCloudUserId) {
        console.error('❌ 无法获取发布者的融云用户ID（手机号），跳过融云推送');
        reject(new Error('无法获取发布者手机号'));
        return;
      }
      
      // 验证手机号格式（中国大陆手机号：11位，1开头）
      if (publisherRongCloudUserId.length !== 11 || !publisherRongCloudUserId.match(/^1[3-9]\d{9}$/)) {
        console.warn('⚠️ 融云用户ID格式异常:', publisherRongCloudUserId, '，跳过融云推送');
        reject(new Error('手机号格式异常'));
        return;
      }
      
      console.log('✅ 发布者融云用户ID验证通过:', publisherRongCloudUserId);
      
      // 🔥 5. 构建活动申请消息（与Flutter保持一致，添加***标识符）
      const activityRequestMessage = `${userName} 申请参加活动：${activityTitle}***`;
      
      console.log('📤 准备通过融云发送活动申请消息:', activityRequestMessage);
      console.log('📤 目标融云用户ID（发布者）:', publisherRongCloudUserId);
      
      // 🔥 6. 调用融云服务发送活动申请推送
      const rongcloud = require('./rongcloud.js');
      
      // 发送融云消息
      rongcloud.sendTextMessage(publisherRongCloudUserId, activityRequestMessage)
        .then(result => {
          console.log('✅ 统一融云活动申请推送发送成功');
          console.log('📨 消息ID:', result.messageId);
          console.log('⏰ 发送时间:', result.sentTime);
          console.log('📤 =============== 统一融云活动申请推送结束 ===============');
          resolve(result);
        })
        .catch(error => {
          console.error('❌ 统一融云活动申请推送发送失败:', error);
          console.error('📤 =============== 统一融云活动申请推送结束（失败） ===============');
          reject(error);
        });
      
    } catch (e) {
      console.error('💥 发送融云活动申请推送异常:', e);
      console.error('📤 =============== 统一融云活动申请推送异常结束 ===============');
      reject(e);
    }
  });
}

/**
 * 发布活动（与 Flutter playtrue3 保持一致）
 * @param {Object} activityData - 活动数据对象
 * @returns {Promise}
 */
function publishActivity(activityData) {
  console.log('📝 =============== 发布活动 ===============');
  console.log('🎯 活动标题:', activityData.activityTitle);
  console.log('👤 发布者ID:', activityData.publisherId);

  // 🔥 构建请求参数（与 Flutter playtrue3 完全一致）
  const requestData = {
    activityTitle: activityData.activityTitle,              // ✅ 必填
    publisherId: activityData.publisherId,                  // ✅ 必填
    publisherNickname: activityData.publisherNickname,      // ✅ 必填
    activityPublishTime: activityData.activityPublishTime,  // ✅ 必填（开始时间）
    latitude: activityData.latitude,                        // ✅ 必填
    longitude: activityData.longitude,                      // ✅ 必填
    timestamp: Math.floor(Date.now() / 1000)                // ✅ 必填（用于加密）
  };

  // 🔥 添加可选参数
  if (activityData.activityDetails) {
    requestData.activityDetails = activityData.activityDetails;
  }
  
  if (activityData.activityLocation) {
    requestData.activityLocation = activityData.activityLocation;
  }
  
  if (activityData.activityImages && activityData.activityImages.length > 0) {
    requestData.activityImages = activityData.activityImages;
  }
  
  if (activityData.activityType && activityData.activityType.length > 0) {
    requestData.activityType = activityData.activityType;
  }
  
  if (activityData.activityTags && activityData.activityTags.length > 0) {
    requestData.activityTags = activityData.activityTags;
  }
  
  if (activityData.activityMaxParticipants) {
    requestData.activityMaxParticipants = activityData.activityMaxParticipants;
  }
  
  if (activityData.publisherAvatarUrl) {
    requestData.publisherAvatarUrl = activityData.publisherAvatarUrl;
  }
  
  if (activityData.publisherSignature) {
    requestData.publisherSignature = activityData.publisherSignature;
  }
  
  if (activityData.publisherTags && activityData.publisherTags.length > 0) {
    requestData.publisherTags = activityData.publisherTags;
  }
  
  if (activityData.publisherPoints !== undefined) {
    requestData.publisherPoints = activityData.publisherPoints;
  }
  
  // 🔥 关键：extraData 包含结束时间（与 Flutter playtrue3 一致）
  if (activityData.extraData) {
    requestData.extraData = activityData.extraData;
  }
  
  // 🔥 免费发布标识（1=免费，0=收费）
  if (activityData.free !== undefined) {
    requestData.free = activityData.free;
  } else {
    requestData.free = 1; // 默认免费
  }

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷已生成');

  // 发送请求
  return request.post('/activities/', encryptedPayload, {
    showLoading: true,
    loadingText: '发布中...'
  }).then(response => {
    console.log('✅ 活动发布成功');
    console.log('📊 响应数据:', response);
    return response;
  }).catch(error => {
    console.error('❌ 活动发布失败:', error);
    throw error;
  });
}

/**
 * 🔥 获取活动参与者列表（与 Flutter 保持一致）
 * @param {number} activityId - 活动ID
 * @returns {Promise}
 */
function getActivityParticipants(activityId) {
  console.log('👥 =============== 获取活动参与者 ===============');
  console.log('📝 活动ID:', activityId);

  // 🔥 构建请求数据（与 Flutter 完全一致）
  // 注意：使用 activity_id（下划线格式），值必须是数字类型
  const requestData = {
    activity_id: parseInt(activityId) // ✅ 使用下划线格式，确保是数字类型
  };

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密（与 Flutter 保持一致）
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷已生成');

  // 🔥 使用POST方式和加密，与 Flutter 保持一致
  return request.post('/activities/participants/edit', encryptedPayload, {
    showLoading: true,
    loadingText: '加载中...'
  }).then(response => {
    console.log('✅ 参与者数据获取成功');
    console.log('📊 参与者数量:', response.data?.total || 0);
    return response;
  }).catch(error => {
    console.error('❌ 参与者数据获取失败:', error);
    throw error;
  });
}

/**
 * 🔥 删除活动参与者（与 Flutter 保持一致）
 * @param {number} activityId - 活动ID
 * @param {number} userId - 用户ID
 * @returns {Promise}
 */
function deleteActivityParticipant(activityId, userId) {
  console.log('🗑️ =============== 删除活动参与者 ===============');
  console.log('📝 活动ID:', activityId);
  console.log('👤 用户ID:', userId);

  // 🔥 构建请求数据（与 Flutter 完全一致）
  // 注意：确保 activityId 和 userId 是数字类型
  const requestData = {
    activityId: parseInt(activityId), // ✅ 确保是数字类型
    userId: parseInt(userId)          // ✅ 确保是数字类型
  };

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷已生成');

  // 发送请求
  return request.post('/activities/participants/delete', encryptedPayload, {
    showLoading: true,
    loadingText: '删除中...'
  }).then(response => {
    console.log('✅ 参与者删除成功');
    console.log('📊 响应数据:', response);
    return response;
  }).catch(error => {
    console.error('❌ 参与者删除失败:', error);
    throw error;
  });
}

/**
 * 编辑活动
 * @param {number} activityId - 活动ID
 * @param {string} activityTitle - 活动标题
 * @param {string} activityDetails - 活动详情
 * @returns {Promise}
 */
function editActivity(activityId, activityTitle, activityDetails) {
  console.log('✏️ =============== 编辑活动 ===============');
  console.log('🆔 活动ID:', activityId);
  console.log('📝 活动标题:', activityTitle);
  console.log('📝 活动详情:', activityDetails);

  // 构建请求数据（参考Flutter实现）
  // 🔥 关键：使用 activityId（驼峰），不是 activity_id（下划线）
  const requestData = {
    activityId: parseInt(activityId),  // 🔥 使用驼峰命名，与Flutter保持一致
    activityTitle: activityTitle,
    activityDetails: activityDetails,
    timestamp: Math.floor(Date.now() / 1000)
  };

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷已生成');

  // 🔥 尝试两种方式：
  // 方式1：POST /activities/edit（根据文档描述）
  // 方式2：PUT /activities/{id}（根据curl测试）
  // 先尝试方式1
  return request.post('/activities/edit', encryptedPayload, {
    showLoading: false  // 页面已经有 loading 状态
  }).then(response => {
    console.log('✅ 活动编辑成功');
    console.log('📊 响应数据:', response);
    return response;
  }).catch(error => {
    console.error('❌ 活动编辑失败:', error);
    throw error;
  });
}

/**
 * 🗑️ 删除活动（软删除 - 通过修改状态实现）
 * 参考Flutter项目：使用编辑接口修改activityStatus为["删除"]
 * @param {number} activityId - 活动ID
 * @param {number} userId - 用户ID（用于权限验证）
 * @returns {Promise}
 */
function deleteActivity(activityId, userId) {
  console.log('🗑️ =============== 删除活动（软删除） ===============');
  console.log('🆔 活动ID:', activityId);
  console.log('👤 用户ID:', userId);
  console.log('🎯 删除方式: 软删除（修改activityStatus为["删除"]）');

  // 🔥 构建请求数据（完全模仿Flutter实现）
  const requestData = {
    activityId: activityId.toString(),  // 转为字符串，与Flutter保持一致
    activityStatus: ['删除'],           // 🎯 关键：设置状态为"删除"实现软删除
    timestamp: Math.floor(Date.now() / 1000)  // Unix秒级时间戳
  };

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密（与Flutter保持一致）
  console.log('🔐 开始AES加密活动删除数据...');
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷已生成');

  // 🚀 发送到编辑接口（与Flutter保持一致）
  console.log('🚀 准备发送加密请求到: /activities/edit');
  
  return request.post('/activities/edit', encryptedPayload, {
    showLoading: false  // 调用方自行控制loading
  }).then(response => {
    console.log('✅ 活动删除成功（软删除）');
    console.log('📊 响应数据:', response);
    return response;
  }).catch(error => {
    console.error('❌ 活动删除失败:', error);
    throw error;
  });
}

/**
 * 查询发布者活动参与者
 * @param {number} publisherId - 发布者ID
 * @returns {Promise}
 */
function getPublisherActivityParticipants(publisherId) {
  console.log('📋 =============== 查询发布者活动参与者 ===============');
  console.log('👤 发布者ID:', publisherId);

  // 构建请求数据
  // 🔥 关键：使用 userid 参数名，与Flutter保持一致（参考activity_api.dart第625行）
  const requestData = {
    userid: publisherId.toString(),  // 使用字符串格式，与Flutter保持一致
    timestamp: Math.floor(Date.now() / 1000)
  };

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷已生成');

  // 发送 POST 请求到 /publisher/activity/participants
  return request.post('/publisher/activity/participants', encryptedPayload, {
    showLoading: false
  }).then(response => {
    console.log('✅ 查询发布者活动参与者成功');
    console.log('📊 响应数据:', response);
    return response;
  }).catch(error => {
    console.error('❌ 查询发布者活动参与者失败:', error);
    throw error;
  });
}

/**
 * 审核参与者申请
 * @param {number} activityId - 活动ID
 * @param {number} userId - 用户ID
 * @param {string} reviewStatus - 审核状态（"通过"或"未通过"）
 * @returns {Promise}
 */
function reviewParticipantApplication(activityId, userId, reviewStatus) {
  console.log('✅ =============== 审核参与者申请 ===============');
  console.log('🎯 活动ID:', activityId);
  console.log('👤 用户ID:', userId);
  console.log('📝 审核状态:', reviewStatus);

  // 构建请求数据
  const requestData = {
    activityId: parseInt(activityId),
    userId: parseInt(userId),
    reviewStatus: reviewStatus,  // "通过" 或 "未通过"
    timestamp: Math.floor(Date.now() / 1000)
  };

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷已生成');

  // 发送 POST 请求到 /activities/participants/review
  return request.post('/activities/participants/review', encryptedPayload, {
    showLoading: false
  }).then(response => {
    console.log('✅ 审核参与者申请成功');
    console.log('📊 响应数据:', response);
    return response;
  }).catch(error => {
    console.error('❌ 审核参与者申请失败:', error);
    throw error;
  });
}

/**
 * 🚩 举报活动（参考Flutter项目实现）
 * @param {number} reporterId - 举报者ID
 * @param {number} activityId - 活动ID
 * @param {string} reportReason - 举报原因
 */
async function reportActivity(reporterId, activityId, reportReason) {
  console.log('🚩 =============== 举报活动 ===============');
  console.log('👤 举报者ID:', reporterId);
  console.log('🎯 活动ID:', activityId);
  console.log('📝 举报原因:', reportReason);
  
  try {
    // 🔥 构建请求参数（与Flutter项目保持一致）
    const requestData = {
      reportType: '活动',  // 固定字符串 "活动"
      reporterId: reporterId.toString(),  // 字符串格式的用户ID
      contentId: activityId,  // 活动ID
      reportReason: reportReason,  // 举报内容
      timestamp: Math.floor(Date.now() / 1000)  // 时间戳
    };
    
    console.log('📊 请求参数:', requestData);
    
    // 🔐 使用AES加密（与其他接口保持一致）
    const encryptedPayload = aes.createEncryptedPayload(requestData);
    console.log('🔐 加密载荷已生成');
    
    // 发送请求
    const response = await request.post('/reports/create/', encryptedPayload);
    
    console.log('📨 举报响应:', response);
    
    if (response.status === 'success') {
      console.log('✅ 举报提交成功');
      return {
        status: 'success',
        message: response.message || '举报提交成功'
      };
    } else {
      console.log('❌ 举报提交失败:', response.message);
      return {
        status: 'error',
        message: response.message || '举报失败'
      };
    }
    
  } catch (error) {
    console.error('💥 举报活动异常:', error);
    return {
      status: 'error',
      message: '举报提交失败: ' + (error.message || error)
    };
  }
}

/**
 * 💰 获取积分套餐列表
 */
async function getPointsPackages() {
  console.log('💰 =============== 获取积分套餐列表 ===============');
  
  try {
    // 构建请求参数（需要timestamp防重放攻击）
    const requestData = {
      timestamp: Math.floor(Date.now() / 1000)
    };
    
    console.log('📊 请求参数（加密前）:', requestData);
    
    // 🔐 使用AES加密
    const encryptedPayload = aes.createEncryptedPayload(requestData);
    console.log('🔐 加密载荷已生成');
    
    // 发送请求
    const response = await request.post('/api/points/packages/', encryptedPayload);
    
    console.log('✅ 积分套餐列表获取成功');
    console.log('📊 响应数据:', response);
    
    return response;
  } catch (error) {
    console.log('💥 获取积分套餐列表异常:', error);
    return {
      status: 'error',
      message: `获取积分套餐失败: ${error.message || error}`
    };
  }
}

/**
 * 💳 创建支付宝支付订单
 * @param {string} userId - 用户ID
 * @param {number} packageId - 积分套餐ID
 */
async function createAlipayOrder(userId, packageId) {
  console.log('💳 =============== 创建支付宝订单 ===============');
  console.log('👤 用户ID:', userId);
  console.log('📦 套餐ID:', packageId);
  
  try {
    // 构建请求参数（明文请求，不加密）
    const requestData = {
      user_id: String(userId),
      package_id: packageId,
      timestamp: Math.floor(Date.now() / 1000)
    };
    
    console.log('📊 请求参数:', requestData);
    
    // 发送请求（明文）
    const response = await request.post('/api/payment/alipay/create_app_order', requestData);
    
    console.log('✅ 支付订单创建成功');
    console.log('📊 响应数据:', response);
    
    return response;
  } catch (error) {
    console.log('💥 创建支付订单异常:', error);
    return {
      status: 'error',
      message: `创建订单失败: ${error.message || error}`
    };
  }
}

/**
 * 🔐 实名认证接口（使用AES加密，与Flutter保持一致）
 * @param {number} userId - 用户ID
 * @param {string} realName - 真实姓名
 * @param {string} idCardNo - 身份证号
 * @returns {Promise}
 */
function realnameAuth(userId, realName, idCardNo) {
  console.log('🔐 =============== 实名认证（AES加密） ===============');
  console.log('👤 用户ID:', userId);
  console.log('📝 姓名:', realName);
  console.log('🆔 身份证:', '***************'); // 隐藏敏感信息

  // 🔥 构建请求数据（与Flutter完全一致）
  const requestData = {
    userid: parseInt(userId),      // 🔥 必须是数字类型（与Flutter一致）
    name: realName,                // 🔥 字段名：name（与Flutter一致）
    id_card_no: idCardNo,          // 🔥 字段名：id_card_no（与Flutter一致）
    timestamp: Math.floor(Date.now() / 1000)  // 🔥 数字类型时间戳
  };

  console.log('📊 请求参数（加密前）:', {
    ...requestData,
    id_card_no: '***************' // 隐藏身份证
  });

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷已生成');

  // 发送请求
  return request.post('/users/real-name-auth/', encryptedPayload, {
    showLoading: false  // 页面自己管理loading
  }).then(response => {
    console.log('✅ 实名认证成功');
    console.log('📊 响应数据:', response);
    return response;
  }).catch(error => {
    console.error('❌ 实名认证失败:', error);
    throw error;
  });
}

/**
 * 📜 查询用户积分变更历史（使用AES加密）
 * @param {string} userId - 用户ID
 * @param {number} page - 页码（默认1）
 */
async function getPointsHistory(userId, page = 1) {
  console.log('📜 =============== 查询积分变更历史（AES加密） ===============');
  console.log('👤 用户ID:', userId);
  console.log('📄 页码:', page);
  
  try {
    // 构建请求参数（参考Flutter项目实现）
    const requestData = {
      userid: String(userId),
      page: page,
      // 注意：不发送page_size参数（参考Flutter项目注释）
      timestamp: Math.floor(Date.now() / 1000)
    };
    
    console.log('📊 请求参数（加密前）:', requestData);
    
    // 🔐 使用AES加密（参考Flutter项目实现）
    const encryptedPayload = aes.createEncryptedPayload(requestData);
    console.log('🔐 加密载荷已生成');
    
    // 发送加密请求
    const response = await request.post('/user/points/history', encryptedPayload);
    
    console.log('✅ 积分变更历史查询成功（AES加密）');
    console.log('📊 响应数据:', response);
    
    return response;
  } catch (error) {
    console.log('💥 查询积分变更历史异常:', error);
    return {
      status: 'error',
      message: `查询历史失败: ${error.message || error}`
    };
  }
}

/**
 * 📋 查询举报信息（参考Flutter项目实现）
 * @param {string} reporterId - 举报者ID
 * @param {number} page - 页码（默认1）
 * @returns {Promise}
 */
function getReportInfo(reporterId, page = 1) {
  console.log('📋 =============== 查询举报信息（AES加密） ===============');
  console.log('👤 举报者ID:', reporterId);
  console.log('📄 页码:', page);

  try {
    // 构建请求数据（完全模仿Flutter项目）
    const requestData = {
      reporterId: reporterId.toString(),  // 字符串格式
      page: page,                         // 数字格式
      timestamp: Math.floor(Date.now() / 1000)  // Unix秒级时间戳
    };

    console.log('📊 请求参数（加密前）:', requestData);

    // 🔥 使用AES加密（与Flutter保持一致）
    console.log('🔐 开始AES加密举报信息查询数据...');
    const encryptedPayload = aes.createEncryptedPayload(requestData);
    
    console.log('🚀 准备发送加密请求到: /reports/query_by_user/');

    // 发送POST请求
    return request.post('/reports/query_by_user/', encryptedPayload, {
      showLoading: false  // 页面自己管理loading状态
    }).then(response => {
      console.log('✅ 举报信息查询成功');
      console.log('📊 响应数据:', response);
      return response;
    }).catch(error => {
      console.error('❌ 查询举报信息失败:', error);
      throw error;
    });
  } catch (error) {
    console.error('💥 查询举报信息异常:', error);
    throw error;
  }
}

/**
 * 📋 查询用户历史记录
 * 
 * 接口地址: POST /users/daily_activities_comments/
 * 参考文档: playtrue3/lib/pages/my/user_history_activite/controller.dart
 * 
 * @param {number} userId - 用户ID
 * @param {string} date - 查询日期 YYYY-MM-DD 格式
 * @param {string} type - 查询类型（'all'=全部, 'activity'=活动, 'comment'=评论）
 * @returns {Promise}
 */
function getUserHistory(userId, date, type = 'all') {
  try {
    console.log('📋 =============== 查询用户历史记录 ===============');
    console.log('👤 用户ID:', userId);
    console.log('📅 查询日期:', date);
    console.log('📝 查询类型:', type);
    
    // 构建请求数据（参考接口文档）
    const requestData = {
      userId: userId,
      date: date,         // 🔥 必须提供日期参数
      type: type,         // 查询类型：all/activity/comment
      timestamp: Math.floor(Date.now() / 1000)  // 时间戳（用于加密）
    };
    
    console.log('📊 请求参数（加密前）:', requestData);
    
    // AES 加密
    const encryptedPayload = aes.createEncryptedPayload(requestData);
    console.log('🔐 加密载荷已生成');
    console.log('🚀 准备发送加密请求到: /users/daily_activities_comments/');
    
    // 发送POST请求
    return request.post('/users/daily_activities_comments/', encryptedPayload, {
      showLoading: false  // 页面自己管理loading状态
    }).then(response => {
      console.log('✅ 历史记录查询成功');
      console.log('📊 响应数据:', response);
      
      // 返回统一格式的数据
      return {
        status: 'success',
        data: response.data || [],
        message: response.message || '查询成功'
      };
    }).catch(error => {
      console.error('❌ 查询历史记录失败:', error);
      throw error;
    });
  } catch (error) {
    console.error('💥 查询历史记录异常:', error);
    throw error;
  }
}

/**
 * 🔒 微信内容安全检测（自动读取 openid）
 * @param {string} content - 需检测的文本内容（最多2500字）
 * @param {number} scene - 场景值（1=资料 2=评论 3=论坛 4=社交日志）
 * @param {Object} options - 可选参数 { title, nickname, signature }
 * @returns {Promise}
 */
function checkContentSecurity(content, scene = 4, options = {}) {
  console.log('🔒 =============== 微信内容安全检测 ===============');
  console.log('📝 内容长度:', content ? content.length : 0);
  console.log('🎯 场景值:', scene, scene === 1 ? '(资料)' : scene === 2 ? '(评论)' : scene === 3 ? '(论坛)' : '(社交日志)');

  // 参数验证
  if (!content || !content.trim()) {
    return Promise.reject(new Error('内容不能为空'));
  }

  if (content.length > 2500) {
    return Promise.reject(new Error('内容超过2500字限制'));
  }

  // 🔥 从 storage 读取 openid（统一管理，不需要外部传入）
  const storage = require('./storage.js');
  const openid = storage.get('wx_openid');
  
  console.log('🔑 从 storage 读取 openid:', openid ? openid : '未找到');

  if (!openid) {
    console.warn('⚠️ 缺少 openid，跳过内容安全检测');
    // 🔥 降级处理：没有 openid 时直接返回成功（不影响用户体验）
    return Promise.resolve({
      status: 'success',
      result: { suggest: 'pass' },
      message: '内容检测已跳过（未登录微信）'
    });
  }

  // 构建请求数据
  const requestData = {
    content: content.trim(),
    openid: openid,
    scene: scene,
    timestamp: Math.floor(Date.now() / 1000)
  };

  // 添加可选参数
  if (options.title) requestData.title = options.title;
  if (options.nickname) requestData.nickname = options.nickname;
  if (options.signature && scene === 1) requestData.signature = options.signature;

  console.log('📊 请求参数（加密前）:', {
    ...requestData,
    content: content.substring(0, 50) + (content.length > 50 ? '...' : '')
  });

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷已生成');

  // 发送请求
  return request.post('/wechat/msg-sec-check/', encryptedPayload, {
    showLoading: false  // 页面自己管理loading
  }).then(response => {
    console.log('✅ 内容安全检测完成');
    console.log('📊 检测结果:', response.result);

    // 返回统一格式
    return {
      status: 'success',
      result: response.result,
      message: response.result.message || '检测完成'
    };
  }).catch(error => {
    console.error('❌ 内容安全检测失败:', error);
    throw error;
  });
}

/**
 * 🖼️ 微信图片内容安全检测（异步，自动读取 openid）
 * @param {string} imageUrl - 要检测的图片URL（必填）
 * @param {number} scene - 场景值（1=资料 2=评论 3=论坛 4=社交日志）
 * @returns {Promise}
 * 
 * 注意：
 * 1. 这是异步接口，调用后立即返回 trace_id
 * 2. 检测结果会在30分钟内通过后端推送接收
 * 3. 图片格式支持：jpg, jpeg, png, bmp, gif
 * 4. 单个文件大小不超过10M
 * 5. 调用频率限制：2000次/分钟，200,000次/天
 */
function checkImageSecurity(imageUrl, scene = 4) {
  console.log('🖼️ =============== 微信图片内容安全检测 ===============');
  console.log('📸 图片URL:', imageUrl);
  console.log('🎯 场景值:', scene, scene === 1 ? '(资料)' : scene === 2 ? '(评论)' : scene === 3 ? '(论坛)' : '(社交日志)');

  // 参数验证
  if (!imageUrl || !imageUrl.trim()) {
    return Promise.reject(new Error('图片URL不能为空'));
  }

  // 🔥 从 storage 读取 openid（统一管理，不需要外部传入）
  const storage = require('./storage.js');
  const openid = storage.get('wx_openid');
  
  console.log('🔑 从 storage 读取 openid:', openid ? openid : '未找到');

  if (!openid) {
    console.warn('⚠️ 缺少 openid，跳过图片内容安全检测');
    // 🔥 降级处理：没有 openid 时直接返回成功（不影响用户体验）
    return Promise.resolve({
      status: 'success',
      trace_id: 'skip_no_openid',
      message: '图片检测已跳过（未登录微信）'
    });
  }

  // 构建请求数据
  const requestData = {
    media_url: imageUrl.trim(),
    media_type: 2,  // 2=图片
    openid: openid,
    scene: scene,
    timestamp: Math.floor(Date.now() / 1000)
  };

  console.log('📊 请求参数（加密前）:', {
    ...requestData,
    media_url: imageUrl.substring(0, 100) + (imageUrl.length > 100 ? '...' : '')
  });

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷已生成');

  // 发送请求
  return request.post('/wechat/media-check-async/', encryptedPayload, {
    showLoading: false  // 页面自己管理loading
  }).then(response => {
    console.log('✅ 图片安全检测已提交');
    console.log('📊 检测结果:', response);

    // 返回统一格式
    return {
      status: 'success',
      trace_id: response.trace_id || '',
      message: response.message || '图片检测已提交'
    };
  }).catch(error => {
    console.error('❌ 图片安全检测失败:', error);
    throw error;
  });
}

/**
 * 🖼️ 批量检测图片内容安全
 * @param {Array<string>} imageUrls - 图片URL数组
 * @param {number} scene - 场景值（1=资料 2=评论 3=论坛 4=社交日志）
 * @returns {Promise<Array>} 返回所有检测结果
 */
function checkMultipleImages(imageUrls, scene = 4) {
  console.log('🖼️ =============== 批量图片内容安全检测 ===============');
  console.log('📊 图片数量:', imageUrls.length);

  if (!imageUrls || imageUrls.length === 0) {
    return Promise.resolve([]);
  }

  // 批量检测所有图片
  const checkPromises = imageUrls.map((url, index) => {
    console.log(`🔍 检测第 ${index + 1}/${imageUrls.length} 张图片`);
    return checkImageSecurity(url, scene);
  });

  return Promise.all(checkPromises).then(results => {
    console.log('✅ 所有图片检测已提交:', results);
    return results;
  }).catch(error => {
    console.error('❌ 批量图片检测失败:', error);
    throw error;
  });
}

/**
 * 🎯 创建活动回复（使用AES加密）
 * @param {Object} replyData - 回复数据对象
 * @param {number} replyData.activityId - 活动ID（必填）
 * @param {number} replyData.activityUserId - 活动用户ID（必填）
 * @param {string} replyData.replyContent - 回复内容（必填）
 * @param {number} replyData.publisherId - 发布者ID（必填）
 * @param {Array<string>} replyData.replyImages - 回复图片数组（可选）
 * @param {number} replyData.parentReplyId - 父回复ID（可选，用于回复的回复）
 * @param {Array<string>} replyData.status - 状态数组（可选，默认["正常"]）
 * @param {Object} replyData.extraData - 额外数据（可选）
 * @returns {Promise}
 */
function createActivityReply(replyData) {
  console.log('🎯 =============== 创建活动回复 ===============');
  console.log('📝 活动ID:', replyData.activityId);
  console.log('👤 活动用户ID:', replyData.activityUserId);
  console.log('👤 发布者ID:', replyData.publisherId);
  console.log('💬 回复内容:', replyData.replyContent?.substring(0, 50) + (replyData.replyContent?.length > 50 ? '...' : ''));

  // 验证必需参数
  if (!replyData.activityId || !replyData.activityUserId || !replyData.replyContent || !replyData.publisherId) {
    return Promise.reject(new Error('缺少必需参数：activityId, activityUserId, replyContent, publisherId'));
  }

  // 构建请求数据（使用AES加密）
  const requestData = {
    activityId: replyData.activityId,
    activityUserId: replyData.activityUserId,
    replyContent: replyData.replyContent,
    publisherId: replyData.publisherId,
    replyImages: replyData.replyImages || [],
    parentReplyId: replyData.parentReplyId || null,
    status: replyData.status || ['正常'],
    extraData: replyData.extraData || {},
    timestamp: Math.floor(Date.now() / 1000)
  };

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷已生成');

  // 发送请求（AES加密）
  return request.post('/activities/reply/create/', encryptedPayload, {
    showLoading: true,
    loadingText: '发送中...'
  }).then(response => {
    console.log('✅ 活动回复创建成功');
    console.log('📊 响应数据:', response);
    return response;
  }).catch(error => {
    console.error('❌ 创建活动回复失败:', error);
    throw error;
  });
}

/**
 * 🔍 查询活动回复列表（使用AES加密）
 * @param {Object} queryParams - 查询参数对象（至少提供一个查询条件）
 * @param {number} queryParams.activityId - 活动ID（可选）
 * @param {number} queryParams.replyId - 回复ID（可选）
 * @param {number} queryParams.publisherId - 发布者ID（可选）
 * @param {number} queryParams.page - 页码（可选，默认1）
 * @param {number} queryParams.pageSize - 每页数量（可选，默认20）
 * @returns {Promise}
 */
function queryActivityReplies(queryParams) {
  console.log('🔍 =============== 查询活动回复 ===============');
  console.log('📝 活动ID:', queryParams.activityId || '未指定');
  console.log('🆔 回复ID:', queryParams.replyId || '未指定');
  console.log('👤 发布者ID:', queryParams.publisherId || '未指定');
  console.log('📄 页码:', queryParams.page || 1);
  console.log('📏 每页数量:', queryParams.pageSize || 20);

  // 验证至少有一个查询条件
  if (!queryParams.activityId && !queryParams.replyId && !queryParams.publisherId) {
    return Promise.reject(new Error('至少需要提供一个查询条件：activityId, replyId 或 publisherId'));
  }

  // 构建请求数据（使用AES加密）
  const requestData = {
    page: queryParams.page || 1,
    pageSize: queryParams.pageSize || 20,
    timestamp: Math.floor(Date.now() / 1000)
  };

  // 添加查询条件
  if (queryParams.activityId) requestData.activityId = queryParams.activityId;
  if (queryParams.replyId) requestData.replyId = queryParams.replyId;
  if (queryParams.publisherId) requestData.publisherId = queryParams.publisherId;

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷已生成');

  // 发送请求（AES加密）
  return request.post('/activities/reply/query/', encryptedPayload, {
    showLoading: true,
    loadingText: '加载中...'
  }).then(response => {
    console.log('✅ 活动回复查询成功');
    console.log('📊 回复数量:', response.data?.replies?.length || 0);
    console.log('📄 分页信息:', response.data?.pagination);
    return response;
  }).catch(error => {
    console.error('❌ 查询活动回复失败:', error);
    throw error;
  });
}

/**
 * 🗑️ 删除活动回复（使用AES加密）
 * @param {number} replyId - 回复ID（必填）
 * @param {number} operatorId - 操作者ID（必填，用于权限验证）
 * @returns {Promise}
 */
function deleteActivityReply(replyId, operatorId) {
  console.log('🗑️ =============== 删除活动回复 ===============');
  console.log('🆔 回复ID:', replyId);
  console.log('👤 操作者ID:', operatorId);

  // 验证必需参数
  if (!replyId) {
    return Promise.reject(new Error('缺少回复ID'));
  }

  if (!operatorId) {
    return Promise.reject(new Error('缺少操作者ID'));
  }

  // 构建请求数据（使用AES加密）
  const requestData = {
    replyId: replyId,
    operatorId: operatorId,
    timestamp: Math.floor(Date.now() / 1000)
  };

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷已生成');

  // 发送请求（AES加密）
  return request.post('/activities/reply/delete/', encryptedPayload, {
    showLoading: true,
    loadingText: '删除中...'
  }).then(response => {
    console.log('✅ 活动回复删除成功');
    console.log('📊 响应数据:', response);
    return response;
  }).catch(error => {
    console.error('❌ 删除活动回复失败:', error);
    throw error;
  });
}

/**
 * 🔍 根据活动用户ID查询回复（使用AES加密）
 * @param {number} activityUserId - 活动用户ID（必填）
 * @param {number} page - 页码（可选，默认1）
 * @param {number} pageSize - 每页数量（可选，默认20）
 * @returns {Promise}
 */
function queryActivityRepliesByUser(activityUserId, page = 1, pageSize = 20) {
  console.log('🔍 =============== 根据活动用户ID查询回复 ===============');
  console.log('👤 活动用户ID:', activityUserId);
  console.log('📄 页码:', page);
  console.log('📏 每页数量:', pageSize);

  // 验证必需参数
  if (!activityUserId) {
    return Promise.reject(new Error('缺少必需参数：activityUserId'));
  }

  // 构建请求数据（使用AES加密）
  // 🔥 关键：使用驼峰格式 activityUserId（与后端接口参数保持一致）
  const requestData = {
    activityUserId: activityUserId,  // ✅ 使用驼峰格式（后端明确要求）
    page: page,
    pageSize: pageSize,
    timestamp: Math.floor(Date.now() / 1000)
  };

  console.log('📊 请求参数（加密前）:', requestData);

  // AES 加密
  const encryptedPayload = aes.createEncryptedPayload(requestData);
  console.log('🔐 加密载荷已生成');

  // 发送请求（AES加密）
  return request.post('/activities/reply/query-by-user/', encryptedPayload, {
    showLoading: true,
    loadingText: '加载中...'
  }).then(response => {
    console.log('✅ 活动用户回复查询成功');
    console.log('📊 回复数量:', response.data?.replies?.length || 0);
    console.log('📄 分页信息:', response.data?.pagination);
    return response;
  }).catch(error => {
    console.error('❌ 查询活动用户回复失败:', error);
    throw error;
  });
}

module.exports = {
  sendSmsCode,
  getPhoneNumber,             // 🔥 微信授权获取手机号接口
  checkPhone,
  registerWithPhone,
  uploadUserImage,
  uploadActivityImage,        // 🖼️ 上传活动图片接口
  updateUserInfo,
  realnameAuth,               // 🔐 实名认证接口
  getNearbyActivities,
  getActivityDetail,
  getUserContent,             // 🔥 获取用户内容接口（查看自己）
  getUserFilteredContent,     // 🔥 获取用户过滤内容接口（查看他人）
  joinActivity,               // 🔥 加入活动接口
  checkFriendRelationship,    // 🔥 检查好友关系接口
  sendFriendRequest,          // 🔥 发送好友申请接口
  getFriendList,              // 👥 获取好友列表接口
  publishActivity,            // 🔥 发布活动接口
  getActivityParticipants,    // 🔥 获取活动参与者接口
  deleteActivityParticipant,  // 🔥 删除活动参与者接口
  editActivity,               // 🔥 编辑活动接口
  deleteActivity,             // 🗑️ 删除活动接口（软删除）
  getPublisherActivityParticipants,  // 🔥 查询发布者活动参与者接口
  reviewParticipantApplication,      // 🔥 审核参与者申请接口
  sendActivityReviewResult,   // 🔥 发送活动审核结果通知（融云IM）
  reportActivity,             // 🔥 举报活动接口
  getPointsPackages,          // 💰 获取积分套餐列表接口
  createAlipayOrder,          // 💳 创建支付宝订单接口
  getPointsHistory,           // 📜 查询积分变更历史接口
  getReportInfo,              // 📋 查询举报信息接口
  getUserHistory,             // 📋 查询用户历史记录接口
  checkContentSecurity,       // 🔒 微信文本内容安全检测接口
  checkImageSecurity,         // 🖼️ 微信图片内容安全检测接口
  checkMultipleImages,        // 🖼️ 批量图片内容安全检测接口
  createActivityReply,        // 🎯 创建活动回复接口（AES加密）
  queryActivityReplies,       // 🔍 查询活动回复接口（AES加密）
  queryActivityRepliesByUser, // 🔍 根据活动用户ID查询回复接口（AES加密）
  deleteActivityReply         // 🗑️ 删除活动回复接口（AES加密）
};

